/*******************************************************************************
 * Copyright 2011-2014 Sergey Tarasevich
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
package com.nostra13.universalimageloader.core;

import ohos.app.Context;
import ohos.global.configuration.DeviceCapability;
import ohos.global.resource.ResourceManager;

import com.nostra13.universalimageloader.cache.disc.DiskCache;
import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
import com.nostra13.universalimageloader.cache.memory.MemoryCache;
import com.nostra13.universalimageloader.cache.memory.impl.FuzzyKeyMemoryCache;
import com.nostra13.universalimageloader.core.assist.FlushedInputStream;
import com.nostra13.universalimageloader.core.assist.ImageSize;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.nostra13.universalimageloader.core.decode.ImageDecoder;
import com.nostra13.universalimageloader.core.download.ImageDownloader;
import com.nostra13.universalimageloader.core.process.BitmapProcessor;
import com.nostra13.universalimageloader.utils.L;
import com.nostra13.universalimageloader.utils.MemoryCacheUtils;

import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.Executor;

/**
 * Presents configuration for {@link ImageLoader}
 *
 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
 * @see ImageLoader
 * @see MemoryCache
 * @see DiskCache
 * @see DisplayImageOptions
 * @see ImageDownloader
 * @see FileNameGenerator
 * @since 1.0.0
 */
public final class ImageLoaderConfiguration {

    /**
     * Resources
     */
    final ResourceManager resources;

    /**
     * Max image width for memory cache
     */
    final int maxImageWidthForMemoryCache;
    /**
     * Max image height for memory cache
     */
    final int maxImageHeightForMemoryCache;
    /**
     * Max image width for disk cache
     */
    final int maxImageWidthForDiskCache;
    /**
     * Max image height for disk cache
     */
    final int maxImageHeightForDiskCache;
    /**
     * Processor for disk cache
     */
    final BitmapProcessor processorForDiskCache;

    /**
     * Task executor
     */
    final Executor taskExecutor;
    /**
     * Task executor for cached images
     */
    final Executor taskExecutorForCachedImages;
    /**
     * Custom executor
     */
    final boolean customExecutor;
    /**
     * Custom executor for cached images
     */
    final boolean customExecutorForCachedImages;

    /**
     * Thread pool size
     */
    final int threadPoolSize;
    /**
     * Thread priority
     */
    final int threadPriority;
    /**
     * Tasks processing type
     */
    final QueueProcessingType tasksProcessingType;

    /**
     * Memory cache
     */
    final MemoryCache memoryCache;
    /**
     * Disk cache
     */
    final DiskCache diskCache;
    /**
     * Downloader
     */
    final ImageDownloader downloader;
    /**
     * Decoder
     */
    final ImageDecoder decoder;
    /**
     * Default display image options
     */
    final DisplayImageOptions defaultDisplayImageOptions;

    /**
     * Network denied downloader
     */
    final ImageDownloader networkDeniedDownloader;
    /**
     * Slow network downloader
     */
    final ImageDownloader slowNetworkDownloader;

    private ImageLoaderConfiguration(final Builder builder) {
        resources = builder.context.getResourceManager();
        maxImageWidthForMemoryCache = builder.maxImageWidthForMemoryCache;
        maxImageHeightForMemoryCache = builder.maxImageHeightForMemoryCache;
        maxImageWidthForDiskCache = builder.maxImageWidthForDiskCache;
        maxImageHeightForDiskCache = builder.maxImageHeightForDiskCache;
        processorForDiskCache = builder.processorForDiskCache;
        taskExecutor = builder.taskExecutor;
        taskExecutorForCachedImages = builder.taskExecutorForCachedImages;
        threadPoolSize = builder.threadPoolSize;
        threadPriority = builder.threadPriority;
        tasksProcessingType = builder.tasksProcessingType;
        diskCache = builder.diskCache;
        memoryCache = builder.memoryCache;
        defaultDisplayImageOptions = builder.defaultDisplayImageOptions;
        downloader = builder.downloader;
        decoder = builder.decoder;

        customExecutor = builder.customExecutor;
        customExecutorForCachedImages = builder.customExecutorForCachedImages;

        networkDeniedDownloader = new NetworkDeniedImageDownloader(downloader);
        slowNetworkDownloader = new SlowNetworkImageDownloader(downloader);

        L.writeDebugLogs(builder.writeLogs);
    }

    /**
     * Creates default configuration for {@link ImageLoader} <br />
     * <b>Default values:</b>
     * <ul>
     * <li>maxImageWidthForMemoryCache = device's screen width</li>
     * <li>maxImageHeightForMemoryCache = device's screen height</li>
     * <li>maxImageWidthForDikcCache = unlimited</li>
     * <li>maxImageHeightForDiskCache = unlimited</li>
     * <li>threadPoolSize = {@link Builder#DEFAULT_THREAD_POOL_SIZE this}</li>
     * <li>threadPriority = {@link Builder#DEFAULT_THREAD_PRIORITY this}</li>
     * <li>allow to cache different sizes of image in memory</li>
     * <li>memoryCache = {@link DefaultConfigurationFactory#createMemoryCache(ohos.app.Context, int)}</li>
     * <li>diskCache = {@link com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiskCache}</li>
     * <li>imageDownloader = {@link DefaultConfigurationFactory#createImageDownloader(Context)}</li>
     * <li>imageDecoder = {@link DefaultConfigurationFactory#createImageDecoder(boolean)}</li>
     * <li>diskCacheFileNameGenerator = {@link DefaultConfigurationFactory#createFileNameGenerator()}</li>
     * <li>defaultDisplayImageOptions = {@link DisplayImageOptions#createSimple() Simple options}</li>
     * <li>tasksProcessingOrder = {@link QueueProcessingType#FIFO}</li>
     * <li>detailed logging disabled</li>
     * </ul>
     *
     * @param context context
     * @return the image loader configuration
     */
    public static ImageLoaderConfiguration createDefault(Context context) {
        return new Builder(context).build();
    }

    /**
     * Gets max image size *
     *
     * @return the max image size
     */
    ImageSize getMaxImageSize() {
		DeviceCapability displayMetrics = resources.getDeviceCapability();
        int width = maxImageWidthForMemoryCache;
		if (width <= 0) {
			width = displayMetrics.width;
		}
        int height = maxImageHeightForMemoryCache;
		if (height <= 0) {
			height = displayMetrics.height;
		}
        return new ImageSize(width, height);
    }

    /**
     * Builder for {@link ImageLoaderConfiguration}
     *
     * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
     */
    public static class Builder {

        private static final String WARNING_OVERLAP_DISK_CACHE_PARAMS = "diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other";
        private static final String WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR = "diskCache() and diskCacheFileNameGenerator() calls overlap each other";
        private static final String WARNING_OVERLAP_MEMORY_CACHE = "memoryCache() and memoryCacheSize() calls overlap each other";
        private static final String WARNING_OVERLAP_EXECUTOR = "threadPoolSize(), threadPriority() and tasksProcessingOrder() calls "
                + "can overlap taskExecutor() and taskExecutorForCachedImages() calls.";

        /**
         * {@value}
         */
        public static final int DEFAULT_THREAD_POOL_SIZE = 3;
        /**
         * {@value}
         */
        public static final int DEFAULT_THREAD_PRIORITY = Thread.NORM_PRIORITY - 2;
        /**
         * {@value}
         */
        public static final QueueProcessingType DEFAULT_TASK_PROCESSING_TYPE = QueueProcessingType.FIFO;

        private Context context;

        private int maxImageWidthForMemoryCache = 0;
        private int maxImageHeightForMemoryCache = 0;
        private int maxImageWidthForDiskCache = 0;
        private int maxImageHeightForDiskCache = 0;
        private BitmapProcessor processorForDiskCache = null;

        private Executor taskExecutor = null;
        private Executor taskExecutorForCachedImages = null;
        private boolean customExecutor = false;
        private boolean customExecutorForCachedImages = false;

        private int threadPoolSize = DEFAULT_THREAD_POOL_SIZE;
        private int threadPriority = DEFAULT_THREAD_PRIORITY;
        private boolean denyCacheImageMultipleSizesInMemory = false;
        private QueueProcessingType tasksProcessingType = DEFAULT_TASK_PROCESSING_TYPE;

        private int memoryCacheSize = 0;
        private long diskCacheSize = 0;
        private int diskCacheFileCount = 0;

        private MemoryCache memoryCache = null;
        private DiskCache diskCache = null;
        private FileNameGenerator diskCacheFileNameGenerator = null;
        private ImageDownloader downloader = null;
        private ImageDecoder decoder;
        private DisplayImageOptions defaultDisplayImageOptions = null;

        private boolean writeLogs = false;

        /**
         * Builder
         *
         * @param context context
         */
        public Builder(Context context) {
            this.context = context.getApplicationContext();
        }

        /**
         * Sets options for memory cache
         *
         * @param maxImageWidthForMemoryCache  Maximum image width which will be used for memory saving during decoding                                     an image to {@link ohos.media.image.PixelMap Bitmap}. <b>Default value - device's screen width</b>
         * @param maxImageHeightForMemoryCache Maximum image height which will be used for memory saving during decoding                                     an image to {@link ohos.media.image.PixelMap Bitmap}. <b>Default value</b> - device's screen height
         * @return the builder
         */
        public Builder memoryCacheExtraOptions(int maxImageWidthForMemoryCache, int maxImageHeightForMemoryCache) {
            this.maxImageWidthForMemoryCache = maxImageWidthForMemoryCache;
            this.maxImageHeightForMemoryCache = maxImageHeightForMemoryCache;
            return this;
        }

        /**
         * Disc cache extra options builder
         *
         * @param maxImageWidthForDiskCache  max image width for disk cache
         * @param maxImageHeightForDiskCache max image height for disk cache
         * @param processorForDiskCache      processor for disk cache
         * @return the builder
         * @deprecated Use  {@link #diskCacheExtraOptions(int, int, BitmapProcessor)} instead
         */
        @Deprecated
        public Builder discCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache,
                                             BitmapProcessor processorForDiskCache) {
            return diskCacheExtraOptions(maxImageWidthForDiskCache, maxImageHeightForDiskCache, processorForDiskCache);
        }

        /**
         * Sets options for resizing/compressing of downloaded images before saving to disk cache.<br />
         * <b>NOTE: Use this option only when you have appropriate needs. It can make ImageLoader slower.</b>
         *
         * @param maxImageWidthForDiskCache  Maximum width of downloaded images for saving at disk cache
         * @param maxImageHeightForDiskCache Maximum height of downloaded images for saving at disk cache
         * @param processorForDiskCache      null-ok; {@linkplain BitmapProcessor Bitmap processor} which process images before saving them in disc cache
         * @return the builder
         */
        public Builder diskCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache,
                                             BitmapProcessor processorForDiskCache) {
            this.maxImageWidthForDiskCache = maxImageWidthForDiskCache;
            this.maxImageHeightForDiskCache = maxImageHeightForDiskCache;
            this.processorForDiskCache = processorForDiskCache;
            return this;
        }

        /**
         * Sets custom {@linkplain Executor executor} for tasks of loading and displaying images.<br />
         * <br />
         * <b>NOTE:</b> If you set custom executor then following configuration options will not be considered for this
         * executor:
         * <ul>
         * <li>{@link #threadPoolSize(int)}</li>
         * <li>{@link #threadPriority(int)}</li>
         * <li>{@link #tasksProcessingOrder(QueueProcessingType)}</li>
         * </ul>
         *
         * @param executor executor
         * @return the builder
         * @see #taskExecutorForCachedImages(Executor) #taskExecutorForCachedImages(Executor)
         */
        public Builder taskExecutor(Executor executor) {
            if (threadPoolSize != DEFAULT_THREAD_POOL_SIZE || threadPriority != DEFAULT_THREAD_PRIORITY || tasksProcessingType != DEFAULT_TASK_PROCESSING_TYPE) {
                L.w(WARNING_OVERLAP_EXECUTOR);
            }

            this.taskExecutor = executor;
            return this;
        }

        /**
         * Sets custom {@linkplain Executor executor} for tasks of displaying <b>cached on disk</b> images (these tasks
         * are executed quickly so UIL prefer to use separate executor for them).<br />
         * <br />
         * If you set the same executor for {@linkplain #taskExecutor(Executor) general tasks} and
         * tasks about cached images (this method) then these tasks will be in the
         * same thread pool. So short-lived tasks can wait a long time for their turn.<br />
         * <br />
         * <b>NOTE:</b> If you set custom executor then following configuration options will not be considered for this
         * executor:
         * <ul>
         * <li>{@link #threadPoolSize(int)}</li>
         * <li>{@link #threadPriority(int)}</li>
         * <li>{@link #tasksProcessingOrder(QueueProcessingType)}</li>
         * </ul>
         *
         * @param executorForCachedImages executor for cached images
         * @return the builder
         * @see #taskExecutor(Executor) #taskExecutor(Executor)
         */
        public Builder taskExecutorForCachedImages(Executor executorForCachedImages) {
            if (threadPoolSize != DEFAULT_THREAD_POOL_SIZE || threadPriority != DEFAULT_THREAD_PRIORITY || tasksProcessingType != DEFAULT_TASK_PROCESSING_TYPE) {
                L.w(WARNING_OVERLAP_EXECUTOR);
            }

            this.taskExecutorForCachedImages = executorForCachedImages;
            return this;
        }

        /**
         * Sets thread pool size for image display tasks.<br />
         * Default value - {@link #DEFAULT_THREAD_POOL_SIZE this}
         *
         * @param threadPoolSize thread pool size
         * @return the builder
         */
        public Builder threadPoolSize(int threadPoolSize) {
            if (taskExecutor != null || taskExecutorForCachedImages != null) {
                L.w(WARNING_OVERLAP_EXECUTOR);
            }

            this.threadPoolSize = threadPoolSize;
            return this;
        }

        /**
         * Sets the priority for image loading threads. Should be <b>NOT</b> greater than {@link Thread#MAX_PRIORITY} or
         * less than {@link Thread#MIN_PRIORITY}<br />
         * Default value - {@link #DEFAULT_THREAD_PRIORITY this}
         *
         * @param threadPriority thread priority
         * @return the builder
         */
        public Builder threadPriority(int threadPriority) {
            if (taskExecutor != null || taskExecutorForCachedImages != null) {
                L.w(WARNING_OVERLAP_EXECUTOR);
            }

            if (threadPriority < Thread.MIN_PRIORITY) {
                this.threadPriority = Thread.MIN_PRIORITY;
            } else {
                if (threadPriority > Thread.MAX_PRIORITY) {
                    this.threadPriority = Thread.MAX_PRIORITY;
                } else {
                    this.threadPriority = threadPriority;
                }
            }
            return this;
        }

        /**
         * When you display an image in a small {@link ohos.agp.components.Image ImageView} and later you try to display
         * this image (from identical URI) in a larger {@link ohos.agp.components.Image ImageView} so decoded image of
         * bigger size will be cached in memory as a previous decoded image of smaller size.<br />
         * So <b>the default behavior is to allow to cache multiple sizes of one image in memory</b>. You can
         * <b>deny</b> it by calling <b>this</b> method: so when some image will be cached in memory then previous
         * cached size of this image (if it exists) will be removed from memory cache before.
         *
         * @return the builder
         */
        public Builder denyCacheImageMultipleSizesInMemory() {
            this.denyCacheImageMultipleSizesInMemory = true;
            return this;
        }

        /**
         * Sets type of queue processing for tasks for loading and displaying images.<br />
         * Default value - {@link QueueProcessingType#FIFO}
         *
         * @param tasksProcessingType tasks processing type
         * @return the builder
         */
        public Builder tasksProcessingOrder(QueueProcessingType tasksProcessingType) {
            if (taskExecutor != null || taskExecutorForCachedImages != null) {
                L.w(WARNING_OVERLAP_EXECUTOR);
            }

            this.tasksProcessingType = tasksProcessingType;
            return this;
        }

        /**
         * Sets maximum memory cache size for {@link ohos.media.image.PixelMap bitmaps} (in bytes).<br />
         * Default value - 1/8 of available app memory.<br />
         * <b>NOTE:</b> If you use this method then
         * {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache} will be used as
         * memory cache. You can use {@link #memoryCache(MemoryCache)} method to set your own implementation of
         * {@link MemoryCache}.
         *
         * @param memoryCacheSize memory cache size
         * @return the builder
         */
        public Builder memoryCacheSize(int memoryCacheSize) {
            if (memoryCacheSize <= 0) throw new IllegalArgumentException("memoryCacheSize must be a positive number");

            if (memoryCache != null) {
                L.w(WARNING_OVERLAP_MEMORY_CACHE);
            }

            this.memoryCacheSize = memoryCacheSize;
            return this;
        }

        /**
         * Sets maximum memory cache size (in percent of available app memory) for {@link ohos.media.image.PixelMap
         * bitmaps}*.<br />
         * Default value - 1/8 of available app memory.<br />
         * <b>NOTE:</b> If you use this method then
         * {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache} will be used as
         * memory cache. You can use {@link #memoryCache(MemoryCache)} method to set your own implementation of
         * {@link MemoryCache}.
         *
         * @param availableMemoryPercent available memory percent
         * @return the builder
         */
        public Builder memoryCacheSizePercentage(int availableMemoryPercent) {
            if (availableMemoryPercent <= 0 || availableMemoryPercent >= 100) {
                throw new IllegalArgumentException("availableMemoryPercent must be in range (0 < % < 100)");
            }

            if (memoryCache != null) {
                L.w(WARNING_OVERLAP_MEMORY_CACHE);
            }

            long availableMemory = Runtime.getRuntime().maxMemory();
            memoryCacheSize = (int) (availableMemory * (availableMemoryPercent / 100f));
            return this;
        }

        /**
         * Sets memory cache for {@link ohos.media.image.PixelMap bitmaps}.<br />
         * Default value - {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache}
         * with limited memory cache size (size = 1/8 of available app memory)<br />
         * <br />
         * <b>NOTE:</b> If you set custom memory cache then following configuration option will not be considered:
         * <ul>
         * <li>{@link #memoryCacheSize(int)}</li>
         * </ul>
         *
         * @param memoryCache memory cache
         * @return the builder
         */
        public Builder memoryCache(MemoryCache memoryCache) {
            if (memoryCacheSize != 0) {
                L.w(WARNING_OVERLAP_MEMORY_CACHE);
            }

            this.memoryCache = memoryCache;
            return this;
        }

        /**
         * Disc cache size builder
         *
         * @param maxCacheSize max cache size
         * @return the builder
         * @deprecated Use {@link #diskCacheSize(int)} instead
         */
        @Deprecated
        public Builder discCacheSize(int maxCacheSize) {
            return diskCacheSize(maxCacheSize);
        }

        /**
         * Sets maximum disk cache size for images (in bytes).<br />
         * By default: disk cache is unlimited.<br />
         * <b>NOTE:</b> If you use this method then
         * {@link com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiskCache LruDiskCache}
         * will be used as disk cache. You can use {@link #diskCache(DiskCache)} method for introduction your own
         * implementation of {@link DiskCache}
         *
         * @param maxCacheSize max cache size
         * @return the builder
         */
        public Builder diskCacheSize(int maxCacheSize) {
            if (maxCacheSize <= 0) throw new IllegalArgumentException("maxCacheSize must be a positive number");

            if (diskCache != null) {
                L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);
            }

            this.diskCacheSize = maxCacheSize;
            return this;
        }

        /**
         * Disc cache file count builder
         *
         * @param maxFileCount max file count
         * @return the builder
         * @deprecated Use {@link #diskCacheFileCount(int)} instead
         */
        @Deprecated
        public Builder discCacheFileCount(int maxFileCount) {
            return diskCacheFileCount(maxFileCount);
        }

        /**
         * Sets maximum file count in disk cache directory.<br />
         * By default: disk cache is unlimited.<br />
         * <b>NOTE:</b> If you use this method then
         * {@link com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiskCache LruDiskCache}
         * will be used as disk cache. You can use {@link #diskCache(DiskCache)} method for introduction your own
         * implementation of {@link DiskCache}
         *
         * @param maxFileCount max file count
         * @return the builder
         */
        public Builder diskCacheFileCount(int maxFileCount) {
            if (maxFileCount <= 0) throw new IllegalArgumentException("maxFileCount must be a positive number");

            if (diskCache != null) {
                L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);
            }

            this.diskCacheFileCount = maxFileCount;
            return this;
        }

        /**
         * Disc cache file name generator builder
         *
         * @param fileNameGenerator file name generator
         * @return the builder
         * @deprecated Use {@link #diskCacheFileNameGenerator(FileNameGenerator)}
         */
        @Deprecated
        public Builder discCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {
            return diskCacheFileNameGenerator(fileNameGenerator);
        }

        /**
         * Sets name generator for files cached in disk cache.<br />
         * Default value -
         * {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createFileNameGenerator()
         * DefaultConfigurationFactory.createFileNameGenerator()}*
         *
         * @param fileNameGenerator file name generator
         * @return the builder
         */
        public Builder diskCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {
            if (diskCache != null) {
                L.w(WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR);
            }

            this.diskCacheFileNameGenerator = fileNameGenerator;
            return this;
        }

        /**
         * Disc cache builder
         *
         * @param diskCache disk cache
         * @return the builder
         * @deprecated Use {@link #diskCache(DiskCache)}
         */
        @Deprecated
        public Builder discCache(DiskCache diskCache) {
            return diskCache(diskCache);
        }

        /**
         * Sets disk cache for images.<br />
         * Default value - {@link com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiskCache
         * UnlimitedDiskCache}*. Cache directory is defined by
         * {@link com.nostra13.universalimageloader.utils.StorageUtils#getCacheDirectory(Context)
         * StorageUtils.getCacheDirectory(Context)}*.<br />
         * <br />
         * <b>NOTE:</b> If you set custom disk cache then following configuration option will not be considered:
         * <ul>
         * <li>{@link #diskCacheSize(int)}</li>
         * <li>{@link #diskCacheFileCount(int)}</li>
         * <li>{@link #diskCacheFileNameGenerator(FileNameGenerator)}</li>
         * </ul>
         *
         * @param diskCache disk cache
         * @return the builder
         */
        public Builder diskCache(DiskCache diskCache) {
            if (diskCacheSize > 0 || diskCacheFileCount > 0) {
                L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);
            }
            if (diskCacheFileNameGenerator != null) {
                L.w(WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR);
            }

            this.diskCache = diskCache;
            return this;
        }

        /**
         * Sets utility which will be responsible for downloading of image.<br />
         * Default value -
         * {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createImageDownloader(Context)
         * DefaultConfigurationFactory.createImageDownloader()}*
         *
         * @param imageDownloader image downloader
         * @return the builder
         */
        public Builder imageDownloader(ImageDownloader imageDownloader) {
            this.downloader = imageDownloader;
            return this;
        }

        /**
         * Sets utility which will be responsible for decoding of image stream.<br />
         * Default value -
         * {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createImageDecoder(boolean)
         * DefaultConfigurationFactory.createImageDecoder()}*
         *
         * @param imageDecoder image decoder
         * @return the builder
         */
        public Builder imageDecoder(ImageDecoder imageDecoder) {
            this.decoder = imageDecoder;
            return this;
        }

        /**
         * Sets default {@linkplain DisplayImageOptions display image options} for image displaying. These options will
         * be used for every {@linkplain ImageLoader#displayImage(String, ohos.agp.components.Image) image display call}
         * without passing custom {@linkplain DisplayImageOptions options}<br />
         * Default value - {@link DisplayImageOptions#createSimple() Simple options}
         *
         * @param defaultDisplayImageOptions default display image options
         * @return the builder
         */
        public Builder defaultDisplayImageOptions(DisplayImageOptions defaultDisplayImageOptions) {
            this.defaultDisplayImageOptions = defaultDisplayImageOptions;
            return this;
        }

        /**
         * Enables detail logging of {@link ImageLoader} work. To prevent detail logs don't call this method.
         * Consider {@link com.nostra13.universalimageloader.utils.L#disableLogging()} to disable
         * ImageLoader logging completely (even error logs)
         *
         * @return the builder
         */
        public Builder writeDebugLogs() {
            this.writeLogs = true;
            return this;
        }

        /**
         * Builds configured {@link ImageLoaderConfiguration} object
         *
         * @return the image loader configuration
         */
        public ImageLoaderConfiguration build() {
            initEmptyFieldsWithDefaultValues();
            return new ImageLoaderConfiguration(this);
        }

        private void initEmptyFieldsWithDefaultValues() {
            if (taskExecutor == null) {
                taskExecutor = DefaultConfigurationFactory
                        .createExecutor(threadPoolSize, threadPriority, tasksProcessingType);
            } else {
                customExecutor = true;
            }
            if (taskExecutorForCachedImages == null) {
                taskExecutorForCachedImages = DefaultConfigurationFactory
                        .createExecutor(threadPoolSize, threadPriority, tasksProcessingType);
            } else {
                customExecutorForCachedImages = true;
            }
            if (diskCache == null) {
                if (diskCacheFileNameGenerator == null) {
                    diskCacheFileNameGenerator = DefaultConfigurationFactory.createFileNameGenerator();
                }
                diskCache = DefaultConfigurationFactory
                        .createDiskCache(context, diskCacheFileNameGenerator, diskCacheSize, diskCacheFileCount);
            }
            if (memoryCache == null) {
                memoryCache = DefaultConfigurationFactory.createMemoryCache(context, memoryCacheSize);
            }
            if (denyCacheImageMultipleSizesInMemory) {
                memoryCache = new FuzzyKeyMemoryCache(memoryCache, MemoryCacheUtils.createFuzzyKeyComparator());
            }
            if (downloader == null) {
                downloader = DefaultConfigurationFactory.createImageDownloader(context);
            }
            if (decoder == null) {
                decoder = DefaultConfigurationFactory.createImageDecoder(writeLogs);
            }
            if (defaultDisplayImageOptions == null) {
                defaultDisplayImageOptions = DisplayImageOptions.createSimple();
            }
        }
    }

    /**
     * Decorator. Prevents downloads from network (throws {@link IllegalStateException exception}).<br />
     * In most cases this downloader shouldn't be used directly.
     *
     * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
     * @since 1.8.0
     */
    private static class NetworkDeniedImageDownloader implements ImageDownloader {

        private final ImageDownloader wrappedDownloader;

        /**
         * Network denied image downloader
         *
         * @param wrappedDownloader wrapped downloader
         */
        public NetworkDeniedImageDownloader(ImageDownloader wrappedDownloader) {
            this.wrappedDownloader = wrappedDownloader;
        }

        @Override
        public InputStream getStream(String imageUri, Object extra) throws IOException {
            switch (Scheme.ofUri(imageUri)) {
                case HTTP:
                case HTTPS:
                    throw new IllegalStateException();
                default:
                    return wrappedDownloader.getStream(imageUri, extra);
            }
        }
    }

    /**
     * Decorator. Handles <a href="http://code.google.com/p/android/issues/detail?id=6066">this problem</a> on slow networks
     * using {@link FlushedInputStream}.
     *
     * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
     * @since 1.8.1
     */
    private static class SlowNetworkImageDownloader implements ImageDownloader {

        private final ImageDownloader wrappedDownloader;

        /**
         * Slow network image downloader
         *
         * @param wrappedDownloader wrapped downloader
         */
        public SlowNetworkImageDownloader(ImageDownloader wrappedDownloader) {
            this.wrappedDownloader = wrappedDownloader;
        }

        @Override
        public InputStream getStream(String imageUri, Object extra) throws IOException {
            InputStream imageStream = wrappedDownloader.getStream(imageUri, extra);
            switch (Scheme.ofUri(imageUri)) {
                case HTTP:
                case HTTPS:
                    return new FlushedInputStream(imageStream);
                default:
                    return imageStream;
            }
        }
    }
}
